home *** CD-ROM | disk | FTP | other *** search
/ The CICA Windows Explosion! / The CICA Windows Explosion! - Disc 2.iso / programr / dpmigcc5.zip / RSX / SOURCE / ASM16 / DPMI16.ASM < prev    next >
Assembly Source File  |  1994-12-12  |  23KB  |  1,569 lines
  1. ;
  2. ; DPMI16.ASM (c) Rainer Schnitker 91,92,93
  3. ;
  4.  
  5. ;
  6. ; 16bit library for DPMI 0.9 calls
  7. ;
  8. ; define 'HAVE386' to use 32bit DPMI mode
  9. ;
  10.  
  11.     .286
  12.     .model SMALL, C
  13.  
  14. ; macro to call dpmi in ax
  15. ;
  16. DPMI MACRO function
  17.     mov ax,function
  18.     int 31h
  19.     ENDM
  20.  
  21. ; error check for dpmi-functions
  22. ; return -1 for dpmi 0.9
  23. ; for dpmi 1.0 replace with "jc @@end" , error code = ax
  24. ;
  25. CHECKERR MACRO
  26.     jnc    short @@ok
  27.     mov    ax, -1
  28.     jmp    short @@end
  29.     ENDM
  30.  
  31. getdword MACRO high,low,address
  32.     mov low,word ptr address
  33.     mov high,word ptr address.2
  34.     ENDM
  35.  
  36. setdword MACRO address,high,low
  37.     mov word ptr address,low
  38.     mov word ptr address.2,high
  39.     ENDM
  40.  
  41.  
  42.     .data
  43.  
  44.     .code
  45.  
  46.  
  47.    ;
  48.    ;    int AllocLDT(WORD anzahl,WORD *sel)
  49.    ;
  50.     public    C AllocLDT
  51. AllocLDT PROC C \
  52.     anzahl    :WORD, \
  53.     sel    :PTR
  54.  
  55.     mov    cx, anzahl
  56.     DPMI 0000h
  57.     CHECKERR
  58. @@ok:
  59.     mov    bx, sel
  60.     mov    word ptr [bx], ax
  61.     xor    ax, ax
  62. @@end:
  63.     ret
  64. AllocLDT    endp
  65.  
  66.    ;
  67.    ;    int FreeLDT(WORD sel)
  68.    ;
  69.     public    C FreeLDT
  70. FreeLDT PROC C \
  71.     sel    :WORD
  72.  
  73.     mov    bx, sel
  74.     DPMI 0001h
  75.     CHECKERR
  76. @@ok:
  77.     xor    ax, ax
  78. @@end:
  79.     ret
  80. FreeLDT     endp
  81.  
  82.    ;
  83.    ;    int SegToSel(WORD seg,WORD *sel)
  84.    ;
  85.     public    C SegToSel
  86. SegToSel PROC C \
  87.     paragr    : WORD , \
  88.     sel    : PTR
  89.  
  90.     mov    bx,paragr
  91.     DPMI 0002h
  92.     CHECKERR
  93. @@ok:
  94.     mov    bx, sel
  95.     mov    word ptr [bx], ax
  96.     xor    ax, ax
  97. @@end:
  98.     ret
  99. SegToSel       endp
  100.  
  101.    ;
  102.    ;    WORD SelInc(void)
  103.    ;
  104.     public    C SelInc
  105. SelInc PROC C
  106.     DPMI 0003h
  107.     ret
  108. SelInc        endp
  109.  
  110.    ;
  111.    ;    int LockSel(WORD sel)  undocumented in dpmi 0.9/1.0
  112.    ;
  113.     public    C LockSel
  114. LockSel PROC C \
  115.     sel    :WORD
  116.  
  117.     mov    bx, sel
  118.     DPMI 0004h
  119.     CHECKERR
  120. @@ok:
  121.     xor    ax, ax
  122. @@end:
  123.     ret
  124. LockSel        endp
  125.  
  126.    ;
  127.    ;    int UnlockSel(WORD sel)  undocumented in dpmi 0.9/1.0
  128.    ;
  129.     public    C UnlockSel
  130. UnlockSel PROC C \
  131.     sel    :WORD
  132.  
  133.     mov    bx,sel
  134.     DPMI 0005h
  135.     CHECKERR
  136. @@ok:
  137.     xor    ax, ax
  138. @@end:
  139.     ret
  140. UnlockSel      endp
  141.  
  142.    ;
  143.    ;    int GetBaseAddress(WORD sel,DWORD *address)
  144.    ;
  145.     public    C GetBaseAddress
  146. GetBaseAddress PROC C \
  147.     sel    :WORD , \
  148.     address :PTR
  149.  
  150.     mov    bx, sel
  151.     DPMI 0006h
  152.     CHECKERR
  153. @@ok:
  154.     mov    bx, address
  155.     setdword [bx],cx,dx
  156.     xor    ax, ax
  157. @@end:
  158.     ret
  159. GetBaseAddress endp
  160.  
  161.    ;
  162.    ;    int SetBaseAddress(WORD sel,DWORD address)
  163.    ;
  164.     public    C SetBaseAddress
  165. SetBaseAddress PROC C \
  166.     sel    :WORD , \
  167.     base    :DWORD
  168.  
  169.     getdword cx,dx,base
  170.     mov    bx, sel
  171.     DPMI 0007h
  172.     CHECKERR
  173. @@ok:
  174.     xor    ax, ax
  175. @@end:
  176.     ret
  177. SetBaseAddress endp
  178.  
  179.    ;
  180.    ;    int SetLimit(WORD sel,DWORD limit)
  181.    ;
  182.     public    C SetLimit
  183. SetLimit PROC C \
  184.     sel    :WORD , \
  185.     limit    :DWORD
  186.  
  187.     mov    bx,sel
  188.     getdword cx,dx,limit
  189.     DPMI 0008h
  190.     CHECKERR
  191. @@ok:
  192.     xor    ax, ax
  193. @@end:
  194.     ret
  195. SetLimit       endp
  196.  
  197.    ;
  198.    ;    int SetAccess(WORD sel,BYTE access,BYTE extaccess)
  199.    ;
  200.     public    C SetAccess
  201. SetAccess PROC C \
  202.     sel    :WORD, \
  203.     access    :BYTE, \
  204.     extaccess :BYTE
  205.  
  206.     mov    bx,sel
  207.     mov    cl,access
  208.     mov    ch,extaccess
  209.     DPMI 0009h
  210.     CHECKERR
  211. @@ok:
  212.     xor    ax, ax
  213. @@end:
  214.     ret
  215. SetAccess      endp
  216.  
  217.    ;
  218.    ;    int CreatAlias(WORD segsel,WORD *alias)
  219.    ;
  220.     public    C CreatAlias
  221. CreatAlias  PROC C \
  222.     segsel    :WORD , \
  223.     alias    :PTR
  224.  
  225.     mov    bx,sel
  226.     DPMI 000Ah
  227.     CHECKERR
  228. @@ok:
  229.     mov    bx,alias
  230.     mov    word ptr [bx],ax
  231.     xor    ax, ax
  232. @@end:
  233.     ret
  234. CreatAlias     endp
  235.  
  236.    ;
  237.    ;    int GetDescriptor(WORD sel,NPDESCRIPTOR desc)
  238.    ;
  239.     public    C GetDescriptor
  240. GetDescriptor PROC C USES DI, \
  241.     sel    :WORD , \
  242.     desc    :PTR
  243.  
  244.     push    ds
  245.     pop    es
  246.     mov    bx,sel
  247. ifdef HAVE386
  248.     .386
  249.     movzx    edi, desc
  250.     .286
  251. else
  252.     mov    di,desc
  253. endif
  254.     DPMI 000Bh
  255.     CHECKERR
  256. @@ok:
  257.     xor    ax, ax
  258. @@end:
  259.     ret
  260. GetDescriptor  endp
  261.  
  262.    ;
  263.    ;    int SetDescriptor(WORD sel,NPDESCRIPTOR desc)
  264.    ;
  265.     public    C SetDescriptor
  266. SetDescriptor PROC C USES DI, \
  267.     sel    :WORD, \
  268.     desc    :PTR
  269.  
  270.     push    ds
  271.     pop    es
  272. ifdef HAVE386
  273.     .386
  274.     movzx    edi, sel
  275.     .286
  276. else
  277.     mov    di,desc
  278. endif
  279.     mov    bx,sel
  280.     DPMI 000Ch
  281.     CHECKERR
  282. @@ok:
  283.     xor    ax, ax
  284. @@end:
  285.     ret
  286. SetDescriptor  endp
  287.  
  288.    ;
  289.    ;    int AllocSpecialLDT(WORD sel)
  290.    ;
  291.     public    C AllocSpecialLDT
  292. AllocSpecialLDT PROC C \
  293.     sel    :WORD
  294.  
  295.     mov    bx,sel
  296.     DPMI 000Dh
  297.     CHECKERR
  298. @@ok:
  299.     xor    ax, ax
  300. @@end:
  301.     ret
  302. AllocSpecialLDT        endp
  303.  
  304.    ;
  305.    ;    int AllocDosMem(WORD paragraphs,WORD *segment,WORD *selector)
  306.    ;
  307.     public    C AllocDosMem
  308. AllocDosMem  PROC C \
  309.     request :WORD , \
  310.     result    :PTR , \
  311.     sel    :PTR
  312.  
  313.     mov    bx,request
  314.     DPMI 0100h
  315.     jnc    short @@ok
  316.     mov    dx,bx
  317.     mov    bx,result
  318.     mov    word ptr [bx],dx
  319.     jmp    short @@end
  320. @@ok:
  321.     mov    bx,result
  322.     mov    word ptr [bx],ax
  323.     mov    bx,sel
  324.     mov    word ptr [bx],dx
  325.     xor    ax, ax
  326. @@end:
  327.     ret
  328. AllocDosMem    endp
  329.  
  330.    ;
  331.    ;    int FreeDosMem(WORD selector)
  332.    ;
  333.     public    C FreeDosMem
  334. FreeDosMem PROC C \
  335.     sel    :WORD
  336.  
  337.     mov    dx,sel
  338.     DPMI 0101h
  339.     CHECKERR
  340. @@ok:
  341.     xor    ax, ax
  342. @@end:
  343.     ret
  344. FreeDosMem     endp
  345.  
  346.    ;
  347.    ;    int ResizeDosMem(WORD paragraphs,WORD oldsel,WORD *maxpara)
  348.    ;
  349.     public    C ResizeDosMem
  350. ResizeDosMem PROC C \
  351.     paragr    :WORD , \
  352.     oldsel    :WORD , \
  353.     maxpara :PTR
  354.  
  355.     mov    bx,paragr
  356.     mov    dx,oldsel
  357.     DPMI 0102h
  358.     jnc    short @@ok
  359.     mov    dx,bx
  360.     mov    bx,maxpara
  361.     mov    word ptr [bx],dx
  362.     jmp    short @@end
  363. @@ok:
  364.     xor    ax, ax
  365. @@end:
  366.     ret
  367. ResizeDosMem   endp
  368.  
  369.    ;
  370.    ;    int GetRealModeVector(BYTE b,WORD *seg,WORD *off)
  371.    ;
  372.     public    C GetRealModeVector
  373. GetRealModeVector PROC C \
  374.     no    :BYTE , \
  375.     segm    :PTR , \
  376.     offs    :PTR
  377.  
  378.     mov    bl,no
  379.     DPMI 0200h
  380.     CHECKERR
  381. @@ok:
  382.     mov    bx,segm
  383.     mov    word ptr [bx],cx
  384.     mov    bx,offs
  385.     mov    word ptr [bx],dx
  386.     xor    ax, ax
  387. @@end:
  388.     ret
  389. GetRealModeVector      endp
  390.  
  391.    ;
  392.    ;    int SetRealModeVector(BYTE b,WORD seg,WORD off)
  393.    ;
  394.     public    C SetRealModeVector
  395. SetRealModeVector PROC C \
  396.     b    :BYTE , \
  397.     segm    :WORD , \
  398.     offs    :WORD
  399.  
  400.     mov    bl,b
  401.     mov    cx,segm
  402.     mov    dx,offs
  403.     DPMI 0201h
  404.     CHECKERR
  405. @@ok:
  406.     xor    ax, ax
  407. @@end:
  408.     ret
  409. SetRealModeVector      endp
  410.  
  411.    ;
  412.    ;    int GetExceptionVector(BYTE b,WORD *sel,WORD *off)
  413.    ;
  414.     public    C GetExceptionVector
  415. GetExceptionVector PROC C \
  416.     no    :BYTE , \
  417.     segm    :PTR , \
  418.     offs    :PTR
  419.  
  420.     mov    bl,no
  421.     DPMI 0202h
  422.     CHECKERR
  423. @@ok:
  424.     mov    bx,segm
  425.     mov    word ptr [bx],cx
  426.     mov    bx,offs
  427.     mov    word ptr [bx],dx
  428.     xor    ax, ax
  429. @@end:
  430.     ret
  431. GetExceptionVector     endp
  432.  
  433. ifdef HAVE386
  434.    ;
  435.    ;    int GetExceptionVector32(BYTE b,WORD *sel,DWORD *off)
  436.    ;
  437.     public    C GetExceptionVector32
  438. GetExceptionVector32 PROC C \
  439.     no    :BYTE , \
  440.     segm    :PTR , \
  441.     offs    :PTR
  442.  
  443.     mov    bl,no
  444.     DPMI 0202h
  445.     CHECKERR
  446. @@ok:
  447.     mov    bx,segm
  448.     mov    word ptr [bx],cx
  449.     mov    bx,offs
  450.     mov    word ptr [bx],dx
  451.     .386
  452.     shr    edx,16
  453.     .286
  454.     mov    word ptr [bx].2,dx
  455.     xor    ax,ax
  456. @@end:
  457.     ret
  458. GetExceptionVector32   endp
  459. endif
  460.  
  461.    ;
  462.    ;    int SetExceptionVector(BYTE b,WORD sel,WORD off)
  463.    ;
  464.     public    C SetExceptionVector
  465. SetExceptionVector PROC C \
  466.     b    :BYTE , \
  467.     segm    :WORD , \
  468.     offs    :WORD
  469.  
  470.     mov    bl,b
  471.     mov    cx,segm
  472.     mov    dx,offs
  473.     DPMI 0203h
  474.     CHECKERR
  475. @@ok:
  476.     xor    ax, ax
  477. @@end:
  478.     ret
  479. SetExceptionVector     endp
  480.  
  481. ifdef HAVE386
  482.    ;
  483.    ;    int SetExceptionVector32(BYTE b,WORD sel,DWORD off)
  484.    ;
  485.     public    C SetExceptionVector32
  486. SetExceptionVector32 PROC C \
  487.     b    :BYTE , \
  488.     segm    :WORD , \
  489.     offs    :DWORD
  490.  
  491.     mov    bl,b
  492.     mov    cx,segm
  493.     .386
  494.     mov    edx,offs
  495.     .286
  496.     DPMI 0203h
  497.     CHECKERR
  498. @@ok:
  499.     xor    ax,ax
  500. @@end:
  501.     .386
  502.     xor    edx,edx
  503.     .286
  504.     ret
  505. SetExceptionVector32   endp
  506. endif
  507.  
  508.    ;
  509.    ;    int GetProtModeVector(BYTE b,WORD *sel,WORD *off)
  510.    ;
  511.     public    C GetProtModeVector
  512. GetProtModeVector PROC C \
  513.     no    :BYTE , \
  514.     segm    :PTR , \
  515.     offs    :PTR
  516.  
  517.     mov    bl,no
  518.     DPMI 0204h
  519.     CHECKERR
  520. @@ok:
  521.     mov    bx,segm
  522.     mov    word ptr [bx],cx
  523.     mov    bx,offs
  524.     mov    word ptr [bx],dx
  525.     xor    ax, ax
  526. @@end:
  527.     ret
  528. GetProtModeVector   endp
  529.  
  530. ifdef HAVE386
  531.    ;
  532.    ;    int GetProtModeVector32(BYTE b,WORD *sel,DWORD *off)
  533.    ;
  534.     public    C GetProtModeVector32
  535. GetProtModeVector32 PROC C \
  536.     no    :BYTE , \
  537.     segm    :PTR , \
  538.     offs    :PTR
  539.  
  540.     mov    bl,no
  541.     DPMI 0204h
  542.     CHECKERR
  543. @@ok:
  544.     mov    bx,segm
  545.     mov    word ptr [bx],cx
  546.     mov    bx,offs
  547.     mov    word ptr [bx],dx
  548.     .386
  549.     shr    edx,16
  550.     .286
  551.     mov    word ptr [bx].2,dx
  552.     xor    ax,ax
  553. @@end:
  554.     ret
  555. GetProtModeVector32 endp
  556. endif
  557.  
  558.    ;
  559.    ;    int SetProtModeVector(BYTE b,WORD sel,WORD off)
  560.    ;
  561.     public    C SetProtModeVector
  562. SetProtModeVector PROC C \
  563.     b    :BYTE , \
  564.     segm    :WORD , \
  565.     offs    :WORD
  566.  
  567.     mov    bl,b
  568.     mov    cx,segm
  569.     mov    dx,offs
  570.     DPMI 0205h
  571.     CHECKERR
  572. @@ok:
  573.     xor    ax, ax
  574. @@end:
  575.     ret
  576. SetProtModeVector   endp
  577.  
  578. ifdef HAVE386
  579.    ;
  580.    ;    int SetProtModeVector32(BYTE b,WORD sel,DWORD off)
  581.    ;
  582.     public    C SetProtModeVector32
  583. SetProtModeVector32 PROC C \
  584.     b    :BYTE , \
  585.     segm    :WORD , \
  586.     offs    :DWORD
  587.  
  588.     mov    bl,b
  589.     mov    cx,segm
  590.     .386
  591.     mov    edx,offs
  592.     .286
  593.     DPMI 0205h
  594.     CHECKERR
  595. @@ok:
  596.     xor    ax, ax
  597. @@end:
  598.     ret
  599. SetProtModeVector32 endp
  600. endif
  601.  
  602.    ;
  603.    ;    int SimulateRMint(BYTE int,BYTE flag,WORD args,NPTRANSLATION call,..)
  604.    ;
  605.     public    C SimulateRMint
  606. SimulateRMint PROC C USES SI DI, \
  607.     intnr    :BYTE, \
  608.     flags    :BYTE, \
  609.     stwords :WORD, \
  610.     trans    :PTR, \
  611.     argv    :BYTE
  612.  
  613.     push    ds        ; small model! ds=ss=es
  614.     pop    es
  615.     mov    cx,stwords
  616.     jcxz    @@simulate
  617. ; copy
  618.     sub    sp, cx        ;
  619.     sub    sp, cx        ; space for cx words
  620.     mov    di, sp
  621.     lea    si, argv
  622.     cld
  623.     rep movsw
  624.  
  625.     mov    cx, stwords    ; reload after movs
  626. @@simulate:
  627.     mov    bh, flags
  628.     mov    bl, intnr
  629. ifdef HAVE386
  630.     .386
  631.     movzx    edi, trans
  632.     .286
  633. else
  634.     mov    di,trans
  635. endif
  636.     DPMI 0300h
  637.     CHECKERR
  638. @@ok:
  639.     xor    ax, ax
  640. @@end:
  641.     mov    cx, stwords
  642.     add    sp,stwords
  643.     add    sp,stwords
  644.     ret
  645. SimulateRMint  endp
  646.  
  647.    ;
  648.    ;    int CallRMprocFar(BYTE flag,WORD args,NPTRANSLATION call,...)
  649.    ;
  650.     public    C CallRMprocFar
  651. CallRMprocFar PROC C USES SI DI , \
  652.     flags    :BYTE, \
  653.     stwords :WORD, \
  654.     trans    :PTR, \
  655.     argv    :BYTE
  656.  
  657.     push    ds        ; small model! ds=ss=es
  658.     pop    es
  659.     mov    cx,stwords
  660.     jcxz    @@simulate
  661. ; copy
  662.     sub    sp, cx
  663.     sub    sp, cx        ; space for cx words
  664.     mov    di, sp
  665.     lea    si, argv
  666.     cld
  667.     rep movsw
  668.  
  669.     mov    cx, stwords
  670. @@simulate:
  671.     xor    bx,bx    ; don't use flags
  672. ifdef HAVE386
  673.     .386
  674.     movzx    edi, trans
  675.     .286
  676. else
  677.     mov    di,trans
  678. endif
  679.     DPMI 0301h
  680.     CHECKERR
  681. @@ok:
  682.     xor    ax, ax
  683. @@end:
  684.     mov    cx, stwords
  685.     add    sp,cx
  686.     add    sp,cx
  687.     ret
  688. CallRMprocFar  endp
  689.  
  690.    ;
  691.    ;    int CallRMprocIret(BYTE flag,WORD args,NPTRANSLATION call,...)
  692.    ;
  693.     public    C CallRMprocIret
  694. CallRMprocIret PROC C USES SI DI, \
  695.     flags    :BYTE, \
  696.     stwords :WORD, \
  697.     trans    :PTR, \
  698.     argv    :BYTE
  699.  
  700.     push    ds        ; small model! ds=ss=es
  701.     pop    es
  702.     mov    cx,stwords
  703.     mov    cx,stwords
  704.     jcxz    @@simulate
  705. ; copy
  706.     sub    sp, cx
  707.     mov    di, sp
  708.     lea    si, argv
  709.     cld
  710.     rep movsw
  711.  
  712.     mov    cx, stwords
  713. @@simulate:
  714.     mov    bh, flags
  715. ifdef HAVE386
  716.     .386
  717.     movzx    edi, trans
  718.     .286
  719. else
  720.     mov    di,trans
  721. endif
  722.     DPMI 0302h
  723.     CHECKERR
  724. @@ok:
  725.     xor    ax, ax
  726. @@end:
  727.     mov    cx, stwords
  728.     add    sp,stwords
  729.     add    sp,stwords
  730.     ret
  731. CallRMprocIret endp
  732.  
  733.    ;
  734.    ;    int AllocRMcallAddress(WORD pmsel,WORD pmoff,NPTRANSLATION call,
  735.    ;                WORD *rmseg,WORD *rmoff)
  736.    ;
  737.     public    C AllocRMcallAddress
  738. AllocRMcallAddress PROC C USES SI DI, \
  739.     pmsel    :WORD , \
  740.     pmoff    :WORD , \
  741.     trans    :PTR ,    \
  742.     rmseg    :PTR ,    \
  743.     rmoff    :PTR
  744.  
  745.     push    ds
  746.     pop    es
  747.     push    ds
  748.     mov    ds,pmsel
  749. ifdef HAVE386
  750.     .386
  751.     movzx    esi, pmoff
  752.     movzx    edi, trans
  753.     .286
  754. else
  755.     mov    si, pmoff
  756.     mov    di, trans
  757. endif
  758.     DPMI 0303h
  759.     pop    ds
  760.     CHECKERR
  761. @@ok:
  762.     mov    bx,rmseg
  763.     mov    word ptr [bx],cx
  764.     mov    bx,rmoff
  765.     mov    word ptr [bx],dx
  766.     xor    ax, ax
  767. @@end:
  768.     ret
  769. AllocRMcallAddress     endp
  770.  
  771.    ;
  772.    ;    int FreeRMcallAddress(WORD rmseg,WORD rmoff)
  773.    ;
  774.     public    C FreeRMcallAddress
  775. FreeRMcallAddress PROC C \
  776.     rmseg    :WORD , \
  777.     rmoff    :WORD
  778.  
  779.     mov    cx,rmseg
  780.     mov    dx,rmoff
  781.     DPMI 0304h
  782.     CHECKERR
  783. @@ok:
  784.     xor    ax, ax
  785. @@end:
  786.     ret
  787. FreeRMcallAddress      endp
  788.  
  789.    ;
  790.    ;    int GetStateSaveAddress(WORD *size,POINTER16_16 *,POINTER16_16 *)
  791.    ;
  792.     public    C GetStateSaveAddress
  793. GetStateSaveAddress PROC C USES SI DI, \
  794.     bytes    :PTR ,    \
  795.     realaddr:PTR ,    \
  796.     protaddr:PTR ,    \
  797.  
  798.     DPMI 0305h
  799.     CHECKERR
  800. @@ok:
  801.     mov    dx, bx
  802.     mov    bx, bytes
  803.     mov    word ptr [bx],ax
  804.     mov    bx, realaddr
  805.     setdword [bx],dx,cx
  806.     mov    bx, protaddr
  807. ifdef HAVE386
  808.     .386
  809.     xor    edi, edi
  810.     .286
  811. endif
  812.     setdword [bx],si,di
  813.     xor    ax, ax
  814. @@end:
  815.     ret
  816. GetStateSaveAddress    endp
  817.  
  818.    ;
  819.    ;    int SaveState(WORD *buffer,POINTER16_16);
  820.    ;
  821.     public    C SaveState
  822. SaveState PROC C USES DI, \
  823.     buffer    :PTR ,    \
  824.     offaddr :BYTE
  825.  
  826.     push    ds
  827.     pop    es
  828. ifdef HAVE386
  829.     .386
  830.     movzx    edi, buffer
  831.     .286
  832. else
  833.     mov    di, buffer
  834. endif
  835.     mov    ax, 0
  836.     call    dword ptr offaddr
  837.     ret
  838. SaveState    endp
  839.  
  840.    ;
  841.    ;    int RestoreState(WORD *buffer,POINTER16_16);
  842.    ;
  843.     public    C RestoreState
  844. RestoreState PROC C USES DI, \
  845.     buffer    :PTR ,    \
  846.     offaddr :BYTE
  847.  
  848.     push    ds
  849.     pop    es
  850. ifdef HAVE386
  851.     .386
  852.     movzx    edi, buffer
  853.     .286
  854. else
  855.     mov    di, buffer
  856. endif
  857.     mov    ax, 1
  858.     call    dword ptr offaddr
  859.     ret
  860. RestoreState       endp
  861.  
  862.    ;
  863.    ;    void GetDPMIVersion(DPMIVERSION *v)
  864.    ;
  865.     public    C GetDPMIVersion
  866. GetDPMIVersion PROC C USES SI, \
  867.     verptr    :PTR
  868.                 ; packed struct req!
  869.     mov    si,verptr
  870.     DPMI 0400h
  871.     mov    byte ptr [si],ah
  872.     mov    byte ptr [si+1],al
  873.     mov    word ptr [si+2],bx
  874.     mov    byte ptr [si+4],cl
  875.     mov    byte ptr [si+5],dh
  876.     mov    byte ptr [si+6],dl
  877.     ret
  878. GetDPMIVersion endp
  879.  
  880.    ;
  881.    ;    int GetFreeMemInfo(NPFREEMEMINFO fm)
  882.    ;
  883.     public    C GetFreeMemInfo
  884. GetFreeMemInfo PROC C USES DI, \
  885.     fm    :PTR
  886.  
  887.     push     ds
  888.     pop     es
  889. ifdef HAVE386
  890.     .386
  891.     movzx    edi, word ptr fm
  892.     .286
  893. else
  894.     mov    di,fm
  895. endif
  896.     DPMI 0500h
  897.     CHECKERR
  898. @@ok:
  899.     xor    ax, ax
  900. @@end:
  901.     ret
  902. GetFreeMemInfo endp
  903.  
  904.    ;
  905.    ;    int AllocMem(DWORD bytes,DWORD *handle,DWORD *memaddress)
  906.    ;
  907.     public    C AllocMem
  908. AllocMem PROC C USES SI DI, \
  909.     nbytes    :DWORD , \
  910.     handle    :PTR , \
  911.     memadr    :PTR
  912.  
  913.     getdword bx,cx,nbytes
  914.     DPMI 0501h
  915.     CHECKERR
  916. @@ok:
  917.     mov    ax,bx
  918.     mov    bx,handle
  919.     setdword [bx],si,di
  920.     mov    bx,memadr
  921.     setdword [bx],ax,cx
  922.     xor    ax, ax
  923. @@end:
  924.     ret
  925. AllocMem       endp
  926.  
  927.    ;
  928.    ;    int FreeMem(DWORD handle)
  929.    ;
  930.     public    C FreeMem
  931. FreeMem PROC C USES SI DI, \
  932.     handle    :DWORD
  933.  
  934.     getdword si,di,handle
  935.     DPMI 0502h
  936.     CHECKERR
  937. @@ok:
  938.     xor    ax, ax
  939. @@end:
  940.     ret
  941. FreeMem        endp
  942.  
  943.    ;
  944.    ;    int ResizeMem(DWORD bytes,DWORD oldhandle,DWORD *newhandle,DWORD *newaddress)
  945.    ;
  946.     public    C ResizeMem
  947. ResizeMem PROC C USES SI DI , \
  948.     nbytes    :DWORD , \
  949.     oldh    :DWORD , \
  950.     newh    :PTR   , \
  951.     newadr    : PTR
  952.  
  953.     getdword bx,cx,nbytes
  954.     getdword si,di,oldh
  955.     DPMI 0503h
  956.     CHECKERR
  957. @@ok:
  958.     mov    ax,bx
  959.     mov    bx,newadr
  960.     setdword [bx],ax,cx
  961.     mov    bx,newh
  962.     setdword [bx],si,di
  963.     xor    ax, ax
  964. @@end:
  965.     ret
  966. ResizeMem      endp
  967.  
  968.    ;
  969.    ;    int LockLinRegion(DWORD size,DWORD address)
  970.    ;
  971.     public    C LockLinRegion
  972. LockLinRegion PROC C USES SI DI, \
  973.     sizeb    :DWORD , \
  974.     addr    :DWORD
  975.  
  976.     getdword bx,cx,addr
  977.     getdword si,di,sizeb
  978.     DPMI 0600h
  979.     CHECKERR
  980. @@ok:
  981.     xor    ax, ax
  982. @@end:
  983.     ret
  984. LockLinRegion  endp
  985.  
  986.    ;
  987.    ;    int UnlockLinRegion(DWORD size,DWORD address)
  988.    ;
  989.     public    C UnlockLinRegion
  990. UnlockLinRegion PROC C USES SI DI, \
  991.     sizeb    :DWORD , \
  992.     address :DWORD
  993.  
  994.     getdword si,di,sizeb
  995.     getdword bx,cx,address
  996.     DPMI 0601h
  997.     CHECKERR
  998. @@ok:
  999.     xor    ax, ax
  1000. @@end:
  1001.     ret
  1002. UnlockLinRegion        endp
  1003.  
  1004.    ;
  1005.    ;    int MarkRealModePageable(DWORD size,DWORD address)
  1006.    ;
  1007.     public    C MarkRealModePageable
  1008. MarkRealModePageable PROC C USES SI DI , \
  1009.     sizeb    :DWORD , \
  1010.     addr    :DWORD
  1011.  
  1012.     getdword bx,cx,addr
  1013.     getdword si,di,sizeb
  1014.     DPMI 0602h
  1015.     CHECKERR
  1016. @@ok:
  1017.     xor    ax, ax
  1018. @@end:
  1019.     ret
  1020. MarkRealModePageable   endp
  1021.  
  1022.    ;
  1023.    ;    int RelockRealModeRegion(DWORD size,DWORD address)
  1024.    ;
  1025.     public    C RelockRealModeRegion
  1026. RelockRealModeRegion PROC C USES SI DI, \
  1027.     sizeb    :DWORD , \
  1028.     addr    :DWORD
  1029.  
  1030.     getdword bx,cx,addr
  1031.     getdword si,di,sizeb
  1032.     DPMI 0603h
  1033.     CHECKERR
  1034. @@ok:
  1035.     xor    ax, ax
  1036. @@end:
  1037.     ret
  1038. RelockRealModeRegion   endp
  1039.  
  1040.    ;
  1041.    ;    int GetPageSize(DWORD *size)
  1042.    ;
  1043.     public    C GetPageSize
  1044. GetPageSize PROC C \
  1045.     sizeb    :PTR
  1046.  
  1047.     DPMI 0604h
  1048.     CHECKERR
  1049. @@ok:
  1050.     mov    ax,bx
  1051.     mov    bx,sizeb
  1052.     setdword [bx],ax,cx
  1053.     xor    ax, ax
  1054. @@end:
  1055.     ret
  1056. GetPageSize    endp
  1057.  
  1058.    ;
  1059.    ;    int MarkPageDemand(DWORD address,DWORD n)
  1060.    ;
  1061.     public    C MarkPageDemand
  1062. MarkPageDemand PROC C USES SI DI , \
  1063.     addr    :DWORD , \
  1064.     nbytes    :DWORD
  1065.  
  1066.     getdword bx,cx,addr
  1067.     getdword si,di,nbytes
  1068.     DPMI 0702h
  1069.     CHECKERR
  1070. @@ok:
  1071.     xor    ax, ax
  1072. @@end:
  1073.     ret
  1074. MarkPageDemand endp
  1075.  
  1076.    ;
  1077.    ;    int DiscardPage(DWORD address,DWORD size)
  1078.    ;
  1079.     public    C DiscardPage
  1080. DiscardPage PROC C USES SI DI , \
  1081.     addr    :DWORD , \
  1082.     sizeb    :DWORD
  1083.  
  1084.     getdword bx,cx,addr
  1085.     getdword si,di,sizeb
  1086.     DPMI 0703h
  1087.     CHECKERR
  1088. @@ok:
  1089.     xor    ax, ax
  1090. @@end:
  1091.     ret
  1092. DiscardPage    endp
  1093.  
  1094.    ;
  1095.    ;    int PhysicalMap(DWORD physical,DWORD size,DWORD *linear)
  1096.    ;
  1097.     public    C PhysicalMap
  1098. PhysicalMap PROC C USES SI DI , \
  1099.     physic    :DWORD , \
  1100.     sizeb    :DWORD , \
  1101.     linear    :PTR
  1102.  
  1103.     getdword bx,cx,physic
  1104.     getdword si,di,sizeb
  1105.     DPMI 0800h
  1106.     CHECKERR
  1107. @@ok:
  1108.     mov    di,linear
  1109.     setdword [di],bx,cx
  1110.     xor    ax, ax
  1111. @@end:
  1112.     ret
  1113. PhysicalMap    endp
  1114.  
  1115.    ;
  1116.    ;    BYTE DisableVirtuelInterruptState()
  1117.    ;
  1118.     public    C DisableVirtuelInterruptState
  1119. DisableVirtuelInterruptState PROC C
  1120.     DPMI 0900h
  1121.     xor    ah,ah
  1122.     ret
  1123. DisableVirtuelInterruptState    endp
  1124.  
  1125.    ;
  1126.    ;    BYTE EnableVirtuelInterruptState()
  1127.    ;
  1128.     public    C EnableVirtuelInterruptState
  1129. EnableVirtuelInterruptState PROC C
  1130.     DPMI 0901h
  1131.     xor    ah,ah
  1132.     ret
  1133. EnableVirtuelInterruptState    endp
  1134.  
  1135.    ;
  1136.    ;    BYTE GetVirtuelInterruptState()
  1137.    ;
  1138.     public    C GetVirtuelInterruptState
  1139. GetVirtuelInterruptState PROC C
  1140.     DPMI 0902h
  1141.     xor    ah,ah
  1142.     ret
  1143. GetVirtuelInterruptState    endp
  1144.  
  1145.    ;
  1146.    ;    int GetVendorEntry(BYTE *p,WORD *sel,WORD *off)
  1147.    ;
  1148.     public    C GetVendorEntry
  1149. GetVendorEntry PROC C USES ES SI DI , \
  1150.     string    :PTR , \
  1151.     sel    :PTR , \
  1152.     offs    :PTR
  1153.  
  1154. ifdef HAVE386
  1155.     .386
  1156.     movzx    edi,string
  1157.     .286
  1158. else
  1159.     mov    di,string
  1160. endif
  1161.     DPMI 0A00h
  1162.     CHECKERR
  1163. @@ok:
  1164.     mov    bx,sel
  1165.     mov    word ptr [bx],es
  1166.     mov    bx,offs
  1167.     mov    word ptr [bx],si
  1168.     xor    ax, ax
  1169. @@end:
  1170.     ret
  1171. GetVendorEntry endp
  1172.  
  1173.    ;
  1174.    ;    int SetDebugWatchpoint(DWORD address,WORD type,WORD *handle)
  1175.    ;
  1176.     public    C SetDebugWatchpoint
  1177. SetDebugWatchpoint PROC C , \
  1178.     addr    :DWORD , \
  1179.     types    :WORD , \
  1180.     handle    :PTR
  1181.  
  1182.     getdword bx,cx,addr
  1183.     mov    dx,types
  1184.     DPMI 0B00h
  1185.     CHECKERR
  1186. @@ok:
  1187.     mov    dx,bx
  1188.     mov    bx,handle
  1189.     mov    word ptr [bx],dx
  1190.     xor    ax, ax
  1191. @@end:
  1192.     ret
  1193. SetDebugWatchpoint     endp
  1194.  
  1195.    ;
  1196.    ;    int ClearDebugWatchpoint(WORD handle)
  1197.    ;
  1198.     public    C ClearDebugWatchpoint
  1199. ClearDebugWatchpoint PROC C \
  1200.     handle    :WORD
  1201.  
  1202.     mov    bx,handle
  1203.     DPMI 0B01h
  1204.     CHECKERR
  1205. @@ok:
  1206.     xor    ax, ax
  1207. @@end:
  1208.     ret
  1209. ClearDebugWatchpoint   endp
  1210.  
  1211.    ;
  1212.    ;    int GetStateDebugWatchpoint(WORD handle,WORD *execute)
  1213.    ;
  1214.     public    C GetStateDebugWatchpoint
  1215. GetStateDebugWatchpoint PROC C \
  1216.     handle    :WORD , \
  1217.     execute :PTR
  1218.  
  1219.     mov    bx,handle
  1220.     DPMI 0B02h
  1221.     CHECKERR
  1222. @@ok:
  1223.     mov    bx,execute
  1224.     mov    [bx],ax
  1225.     xor    ax, ax
  1226. @@end:
  1227.     ret
  1228. GetStateDebugWatchpoint        endp
  1229.  
  1230.    ;
  1231.    ;    int ResetDebugWatchpoint(WORD handle)
  1232.    ;
  1233.     public    C ResetDebugWatchpoint
  1234. ResetDebugWatchpoint PROC C \
  1235.     handle    :WORD
  1236.  
  1237.     mov    bx,handle
  1238.     DPMI 0B03h
  1239.     CHECKERR
  1240. @@ok:
  1241.     xor    ax, ax
  1242. @@end:
  1243.     ret
  1244. ResetDebugWatchpoint   endp
  1245.  
  1246.  
  1247. ;
  1248. ; Protected mode instructions
  1249. ;
  1250.  
  1251.     .286p
  1252.  
  1253.    ;
  1254.    ;    WORD lsl16(WORD sel)    16-bit version of lsl for 80286
  1255.    ;
  1256.     public    C lsl16
  1257. lsl16 PROC C \
  1258.     sel    :WORD
  1259.  
  1260.     xor     ax, ax
  1261.     lsl     ax,sel
  1262.     ret
  1263. lsl16  endp
  1264.  
  1265. ifdef HAVE386
  1266.    ;
  1267.    ;    DWORD lsl32(WORD sel)  /* load selector limit for 80386 */
  1268.    ;
  1269.     public    C lsl32
  1270. lsl32  PROC C \
  1271.     sel    :WORD
  1272.  
  1273.     .386p
  1274.     movzx    ebx,sel
  1275.     lsl    eax,ebx
  1276.     mov    edx,eax
  1277.     shr    edx,16
  1278.     and    eax,dword ptr 0ffffh
  1279.     .286p
  1280.     ret
  1281. lsl32  endp
  1282. endif
  1283.  
  1284.    ;
  1285.    ;    WORD lar16(WORD sel)    16-bit version of lar for 80286
  1286.    ;
  1287.     public    C lar16
  1288. lar16 PROC C \
  1289.     sel    :WORD
  1290.  
  1291.     xor     ax, ax
  1292.     lar     ax,sel
  1293.     shr     ax,8
  1294.     ret
  1295. lar16  endp
  1296.  
  1297. ifdef HAVE386
  1298.    ;
  1299.    ;    WORD lar16(WORD sel)    16-bit version of lar for 80286
  1300.    ;
  1301.     public    C lar32
  1302. lar32  PROC C \
  1303.     sel    :WORD
  1304.     .386p
  1305.     movzx    ebx,sel
  1306.     lar    eax,ebx
  1307.     mov    edx,eax
  1308.     shr    edx,16
  1309.     and    eax,dword ptr 0ffffh
  1310.     .286p
  1311.     ret
  1312. lar32  endp
  1313. endif
  1314.  
  1315.    ;
  1316.    ;    WORD verr(WORD sel)    verify read
  1317.    ;
  1318.     public    C verr16
  1319. verr16 PROC C \
  1320.     sel    :WORD
  1321.  
  1322.     mov    ax,1
  1323.     verr    sel
  1324.     je    short @@nok
  1325.     dec    ax
  1326. @@nok:
  1327.     ret
  1328. verr16 endp
  1329.  
  1330.    ;
  1331.    ;    WORD verw(WORD sel)    verify write
  1332.    ;
  1333.     public    C verw16
  1334. verw16 PROC C \
  1335.     sel    :WORD
  1336.  
  1337.     mov    ax,1
  1338.     verw    sel
  1339.     je    short @@nok
  1340.     dec    ax
  1341. @@nok:
  1342.     ret
  1343. verw16 endp
  1344.  
  1345.    ;
  1346.    ;    void sgdt(LPGDTR g)    save gdt table
  1347.    ;
  1348.     public    C sgdt16
  1349. sgdt16 PROC C \
  1350.     g    :DWORD
  1351.  
  1352.     les     bx,g
  1353.     sgdt     es:[bx]
  1354.     ret
  1355. sgdt16 endp
  1356.  
  1357.    ;
  1358.    ;    void sidt(LPGDTR g)    save idt table
  1359.    ;
  1360.     public    C sidt16
  1361. sidt16 PROC C \
  1362.     g    :DWORD
  1363.  
  1364.     les     bx,g
  1365.     sidt     es:[bx]
  1366.     ret
  1367. sidt16 endp
  1368.  
  1369.    ;
  1370.    ;    WORD sldt(void)     save ldt-selector
  1371.    ;
  1372.     public    C sldt16
  1373. sldt16 PROC C
  1374.     sldt     ax
  1375.     ret
  1376. sldt16 endp
  1377.  
  1378.    ;
  1379.    ;    WORD str16(void)      save task-register
  1380.    ;
  1381.     public    C str16
  1382. str16 PROC C
  1383.     str     ax
  1384.     ret
  1385. str16  endp
  1386.  
  1387.    ;
  1388.    ;    void far * IncFP(void far *a)    increment far piointer
  1389.    ;
  1390.     public    C IncFP
  1391. IncFP PROC C \
  1392.     aptr    :DWORD
  1393.  
  1394.     call    near ptr SelInc
  1395.     mov    cx, ax
  1396.     getdword dx,ax,aptr
  1397.     add    dx,cx
  1398.     ret
  1399. IncFP  endp
  1400.  
  1401.    ;
  1402.    ;    void far * DecFP(void far *a)    decrement far pointer
  1403.    ;
  1404.     public    C DecFP
  1405. DecFP PROC C \
  1406.     aptr    :DWORD
  1407.  
  1408.     call    near ptr SelInc
  1409.     mov    cx, ax
  1410.     getdword dx,ax,aptr
  1411.     sub    dx,cx
  1412.     ret
  1413. DecFP  endp
  1414.  
  1415.    ;
  1416.    ;    int IsPM()    execute in prot-mode ? ax==0, PMode under DPMI
  1417.    ;
  1418.     public    C IsPM
  1419. IsPM PROC C
  1420.     mov    ax,1686h
  1421.     int    02FH
  1422.     ret
  1423. IsPM   endp
  1424.  
  1425.    ;
  1426.    ;    int IsWindowsEnhanced(void)
  1427.    ;
  1428.     public    C IsWindowsEnhanced
  1429. IsWindowsEnhanced PROC C
  1430.     mov    ax,01600H
  1431.     int    02fH
  1432.     cmp    al,3
  1433.     jb    short @@not
  1434.     cmp    al,10
  1435.     ja    short @@not
  1436.     mov    ax, 1
  1437.     jmp    short @@end
  1438. @@not:
  1439.     xor    ax, ax
  1440. @@end:
  1441.     ret
  1442. IsWindowsEnhanced      endp
  1443.  
  1444.    ;
  1445.    ;    void yield() /* give control to operating system (like GetMassage) */
  1446.    ;
  1447.     public    C yield
  1448. yield PROC C
  1449.     mov    ax,1680H
  1450.     int    2Fh
  1451.     ret
  1452. yield  endp
  1453.  
  1454.     public dos_exit
  1455. dos_exit PROC C \
  1456.     errorlevel:WORD
  1457.  
  1458.     mov    ax, errorlevel
  1459.     mov    ah, 04Ch
  1460.     int    021h
  1461.     ret
  1462. dos_exit endp
  1463.  
  1464.     public DpmiEnableFpu
  1465. DpmiEnableFpu PROC C \
  1466.     bits    :WORD
  1467.  
  1468.     mov    bx, bits
  1469.     DPMI 0E01h
  1470.     CHECKERR
  1471. @@ok:
  1472.     xor    ax, ax
  1473. @@end:
  1474.     ret
  1475. DpmiEnableFpu endp
  1476.  
  1477.     public C DpmiDisableFpu
  1478. DpmiDisableFpu PROC C
  1479.     mov    bx, 0
  1480.     DPMI 0E01h
  1481.     CHECKERR
  1482. @@ok:
  1483.     xor    ax, ax
  1484. @@end:
  1485.     ret
  1486. DpmiDisableFpu endp
  1487.  
  1488.     public C GetCS
  1489. GetCS PROC C
  1490.     mov    ax,cs
  1491.     ret
  1492. GetCS endp
  1493.  
  1494.     public C GetDS
  1495. GetDS PROC C
  1496.     mov    ax,ds
  1497.     ret
  1498. GetDS endp
  1499.  
  1500.     public C GetES
  1501. GetES PROC C
  1502.     mov    ax,es
  1503.     ret
  1504. GetES endp
  1505.  
  1506.     public C GetDpmiEntryPoint
  1507. GetDpmiEntryPoint PROC C USES SI DI , \
  1508.     entry    :PTR, \
  1509.     dpmipara:PTR, \
  1510.     flags    :PTR, \
  1511.     dpmiver :PTR, \
  1512.     cpu    :PTR
  1513.  
  1514.     mov    ax, 1687h
  1515.     int    2Fh
  1516.     or    ax,ax
  1517.     jnz    noDPMI
  1518.     mov    ax, bx        ; save bx = bits
  1519.  
  1520.     mov    bx, entry
  1521.     mov    [bx], di
  1522.     mov    [bx+2], es
  1523.     mov    bx, flags
  1524.     mov    [bx], ax
  1525.     mov    bx, dpmiver
  1526.     mov    [bx], dx
  1527.     mov    bx, cpu
  1528.     mov    [bx], cl
  1529.     mov    bx, dpmipara
  1530.     mov    [bx], si
  1531.     xor    ax, ax
  1532. noDPMI:
  1533.     ret
  1534. GetDpmiEntryPoint endp
  1535.  
  1536.     public C GetDpmiHostParagraph
  1537. GetDpmiHostParagraph PROC C \
  1538.     dpmipara:WORD
  1539.  
  1540.     mov    bx, dpmipara
  1541.     mov    ah, 48h
  1542.     int    21h
  1543.     jnc    @@end
  1544.     or    ax,ax
  1545. @@end:
  1546.     ret
  1547. GetDpmiHostParagraph endp
  1548.  
  1549.     public C DpmiEnterProtectedMode
  1550. DpmiEnterProtectedMode PROC C \
  1551.     entry    :DWORD, \
  1552.     flags    :WORD, \
  1553.     parasegm:WORD
  1554.  
  1555.     mov    ax, parasegm
  1556.     mov    es, ax
  1557.     mov    ax, flags
  1558.     call    dword ptr entry
  1559.     jnc    @@ok
  1560.     mov    ax, -1
  1561.     jmp    short @@end
  1562. @@ok:
  1563.     xor    ax, ax
  1564. @@end:
  1565.     ret
  1566. DpmiEnterProtectedMode endp
  1567.  
  1568.     end
  1569.